Lambda the Ultimate

While studying the conference program of the upcoming OOPSLA 2006 I discovered under the category "essay" an author who has quite something critical to say about AOP:

Aspect-oriented programming is discussed as a promising new technology. Like object-oriented programming, it is beginning to pervade all areas of software engineering. With its growing popularity, practitioners and academics alike are beginning to wonder whether they should start looking into or it, or otherwise risk having missed an important development. The author of this essay finds that much of aspect-oriented programming's success seems to be based on the conception that it improves both modularity and the structure of code, while in fact, it actually works against the primary purposes of the two, namely independent development and understandability of programs. Not seeing any way of fixing this situation, he thinks the success of aspect-oriented programming to be paradoxical.

This is not just another internet rant about the latest PL hype but the author, Friedrich Steimann, had done interesting work about AOP before. In particular his latest paper about typed AOP:

AOP and the antinomy of the liar

but also his award winning former critical AOP review:

Domain models are aspect free

Back when Python was all the rage, we often discussed metaprogramming tricks in Python. Well, it seems the metaprogramming action has moved to Ruby, just like everything else... ;-)

Matti Rintala, Handling multiple concurrent exceptions in C++ using futures.

Aside from describing the way exceptions are handled in KC++, a concurrent C++ sytem based on active objects, this nice paper provides a short and readable description of the main difficulties in combining exceptions and asynchronous calls.

The KC++ approach is library based, and the paper explains how KC++ matches itself to the C++ exception handling model.

The description of the Ada model, in section 7, may be a bit unclear. Specifically, a nuance that is easy to overlook is that exceptions raised within an accept statement (and not handled there) are propagated both in the calling and in the called tasks. The Ada83 Rationale explains this in more detail and gives examples of use.

From an historical perspective it is a bit amusing (and also quite sad) that the issues resulting from the interaction of concurrency and exceptions, that the Ada designers had to tackle in late '70s early 80s, still occupy the time of language desginers today.

Andreeesen discusses the problems with programming languages prior to 1995 and how things changed with the development of Java, followed by JavaScript and PHP. These languages were easier to learn and allowed for easier cross platform use and quick deployment. In addition, with the meteoric drop in hardware and network costs, more powerful applications will be much easier to develop and worldwide collaboration is possible.

A personal view on programming language history, biased in favor of dynamic languages and specifically PHP (audio show).

Feel free to comment on the historical accuracy and/or Andreeesen's central argument.

Samurai - Protecting Critical Heap Data in Unsafe Languages.
Karthik Pattabiraman, Vinod Grover, Benjamin G. Zorn.
September 2006.

Programs written in type-unsafe languages such as C and C++ incur costly memory safety errors that result in corrupted data structures, program crashes, and incorrect results. Previous approaches to eliminating these errors attempt to eliminate all unsafe memory operations in a program. We present Samurai, a runtime system that allows programmers to selectively identify heap objects that are critical to correct execution of their program. Samurai supports operations to consistently read and update critical data and probabilistically guarantees that no other memory updates in the program will corrupt critical data. Samurai uses replication and randomization to provide these consistency guarantees. Because Samurai is oblivious to memory operations on noncritical data, the majority of memory operations in programs run at full speed, and Samurai is compatible with 3rd party libraries. We have annotated five benchmark programs with Samurai and we present measurements of the execution overhead and fault tolerance that Samurai provides. Samurai can be applied selectively to parts of a program’s heap allowing the execution overhead to be tailored for the needs of a particular application.

Essentially, you use a custom memory allocator for critical objects, so that they are stored redundantly (i.e, they are replicated).

Related reading: Failure-oblivious computing.

SecPAL: Design and Semantics of a Decentralized Authorization Language. Moritz Y. Becker; Andrew D. Gordon; Cédric Fournet. September 2006

We present a declarative authorization language. Policies and credentials are expressed using predicates defined by logical clauses, in the style of constraint logic programming. Access requests are mapped to logical authorization queries, consisting of predicates and constraints combined by conjunctions, disjunctions, and negations. Access is granted if the query succeeds against the current database of clauses. Predicates ascribe rights to particular principals, with flexible support for delegation and revocation. At the discretion of the delegator, delegated rights can be further delegated, either to a fixed depth, or arbitrarily deeply.

Our language strikes a fine balance between semantic simplicity, policy expressiveness, and execution efficiency. The semantics consists of just three deduction rules. The language can express many common policy idioms using constraints, controlled delegation, recursive predicates, and negated queries. We describe an execution strategy based on translation to Datalog with constraints and table-based resolution. We show that this execution strategy is sound, complete, and always terminates, despite recursion and negation, as long as simple syntactic conditions are met.

The SecPAL project lives here (MSR). The project aims are to develop a language for expressing decentralized authorization policies, and to investigate language design and semantics, as well as related algorithms and analysis techniques.

Via Mitch Wand's R6RS announcements mailing list:

I am extremely pleased to announce that a draft version of R6RS is now available at www.r6rs.org. A copy will also be posted on schemers.org.

The charter provides for a six-month public comment period. Therefore the editors, in consultation with the steering committee, have provided a mechanism for comment and discussion. Details are also at www.r6rs.org.

The comment period is now open and will continue until March 15, 2007.

The steering committee thanks the editors for their intensive work on the draft R6RS, and looks forward to the public comment period.

Enjoy!

For the Steering Committee,
--Mitch Wand

"... I believe that the development of AppleScript is a story worth telling, and I have been encouraged to attempt it despite the inherent difficulty of the task. I can only offer my own subjective views on the project, as someone who was intimately involved with all its aspects. ..."

The program for the Dynamic Languages Symposium at OOPSLA is online.

The three invited talks look especially interesting. After the long nuclear winter caused by Java, it seems that we finally are entering a period of programming language renaissance.

by Neil Ghani and Patricia Johann:

Initial algebra semantics is one of the cornerstones of the theory of modern programming languages. It provides support for fold combinators encapsulating structured recursion over data structures, thereby making it possible to both reason about and transform programs in principled ways. Recently, Ghani, Uustalu, and Vene extended the usual initial algebra semantics to support not only standard fold combinators for inductive types, but also Church encodings and build combinators for them. In addition to being theoretically useful in ensuring that build is seen as a fundamental part of the basic infrastructure for programming with inductive types, this development has practical merit: the fold and build combinators can be used to define fold/build rules which optimise modularly constructed programs by eliminating intermediate inductive data structures.

In this paper, we apply this extended initial algebra semantics to the theory and practice of programming with nested data types. In particular, we use it to simplify the theory of folds for nested types, as well as to provide the first Church encodings, build combinators, and fold/build fusion rules for them.

Code for "Folds, Church Encodings, Builds, and Short Cut Fusion for Nested Types: A Principled Approach"